﻿using System;
using System.Collections.Generic;

namespace Tools
{
    /// <summary>
    /// string的拓展
    /// </summary>
    public static class StringExtends
    {
        #region 在一个区间查找内容，通过字符串

        /// <summary>
        /// 在一个区间查找内容
        /// 如果没有找到结束符号 则取开始符号之后的所有内容
        /// </summary>
        /// <param name="content">原始内容</param>
        /// <param name="startStr">起始字符串</param>
        /// <param name="endStr">结束字符串</param>
        /// <returns>在起始和结束字符串之间的字符串结果，不包含起始和结束</returns>
        public static string Find(this string content, string startStr, string endStr = "")
        {
            string result = string.Empty;
            int startIndex = content.IndexOf(startStr);
            if (startIndex >= 0)
            {
                if (string.IsNullOrEmpty(endStr))
                {
                    result = content.Substring(startIndex + startStr.Length);
                }
                else
                {
                    int endIndex = content.IndexOf(endStr, startIndex + startStr.Length);
                    if (endIndex >= 0)
                    {
                        result = content.Substring(startIndex + startStr.Length, endIndex - startIndex - startStr.Length);
                    }
                    else
                    {
                        result = content.Substring(startIndex + startStr.Length);
                    }
                }
            }

            return result;
        }

        #endregion 在一个区间查找内容，通过字符串

        #region 在一个区间查找内容，通过下标

        /// <summary>
        /// 在一个区间查找内容
        /// 如果没有找到结束符号 则取开始符号之后的所有字符
        /// </summary>
        /// <param name="content">原始内容</param>
        /// <param name="startIndex">起始位置</param>
        /// <param name="endIndex">结束位置</param>
        /// <returns>查找到的内容</returns>
        public static string Find(this string content, int startIndex, int? endIndex = null)
        {
            string result = string.Empty;
            if (startIndex < 0)
            {
                startIndex = 0;
            }

            if (content.Length > startIndex)
            {
                if (endIndex != null)
                {
                    if (endIndex > startIndex && endIndex < content.Length)
                    {
                        result = content.Substring(startIndex, (int)endIndex - startIndex);
                    }
                    else
                    {
                        result = content.Substring(startIndex);
                    }
                }
                else
                {
                    result = content.Substring(startIndex);
                }
            }
            return result;
        }

        #endregion 在一个区间查找内容，通过下标

        #region 替换一个区间内容

        /// <summary>
        /// 替换一个区间内容
        /// 没有结束字符就从开始替换到最后
        /// </summary>
        /// <param name="content">原始内容</param>
        /// <param name="startStr">起始字符串</param>
        /// <param name="newStr">替换的新内容</param>
        /// <param name="endStr">结束字符串</param>
        /// <returns>替换后的新内容</returns>
        public static string Replace(this string content, string startStr, string newStr, string endStr = "")
        {
            string result = string.Empty;
            int startIndex = content.IndexOf(startStr);
            if (startIndex >= 0)
            {
                var startOne = startIndex + startStr.Length;  // 开始字符串的结束位置
                if (string.IsNullOrEmpty(endStr))
                {
                    result = content.Remove(startOne);
                    result += newStr;
                }
                else
                {
                    int endIndex = content.IndexOf(endStr);
                    if (endIndex >= 0)
                    {
                        result = content.Remove(startOne, endIndex - startIndex - startStr.Length);
                        result = result.Insert(startOne, newStr);
                    }
                    else
                    {
                        result = content.Remove(startOne) + newStr;
                    }
                }
            }
            return result;
        }

        #endregion 替换一个区间内容

        #region 逐行查找指定一个区间的内容

        /// <summary>
        /// 逐行查找指定一个区间的内容
        /// 如果没有找到结束符号 则取开始符号之后的所有字符
        /// </summary>
        /// <param name="content">原始内容</param>
        /// <param name="startStr">起始字符串</param>
        /// <param name="endStr">结束字符串</param>
        /// <returns>查找到的所有行</returns>
        public static List<string> FindByLine(this string content, string startStr, string endStr = "")
        {
            var result = new List<string>(1);
            string[] rows = content.Split(new string[] { "\r\n", "\r", "\n" }, StringSplitOptions.None);
            foreach (string value in rows)
            {
                if (!value.Contains(startStr)) continue;
                int startIndex = value.IndexOf(startStr);

                if (string.IsNullOrEmpty(endStr))
                {
                    result.Add(value.Substring(startIndex + startStr.Length));
                    continue;
                }

                int endIndex = value.IndexOf(endStr, startIndex + startStr.Length);
                if (endIndex > startIndex)//结束位置正确
                {
                    result.Add(value.Substring(startIndex + startStr.Length, endIndex - startIndex - startStr.Length));
                }
                else
                {
                    result.Add(value.Substring(startIndex + startStr.Length));
                }
            }
            return result;
        }

        #endregion 逐行查找指定一个区间的内容

        #region 逐行查找指定区间的第一个匹配项

        /// <summary>
        /// 逐行查找指定区间的第一个匹配项
        /// 如果没有找到结束符号，则取开始符号之后的所有字符
        /// </summary>
        /// <param name="content">原始内容</param>
        /// <param name="startStr">起始字符串</param>
        /// <param name="endStr">结束字符串</param>
        /// <returns>第一个匹配项行中查找到的内容</returns>
        public static string FindByLineFirst(this string content, string startStr, string endStr = "")
        {
            var results = content.FindByLine(startStr, endStr);
            return results.Count > 0 ? results[0] : string.Empty;
        }

        #endregion 逐行查找指定区间的第一个匹配项

        #region 逐行查找指定区间的最后一个匹配项

        /// <summary>
        /// 逐行查找指定区间的最后一个匹配项
        /// 如果没有找到结束符号，则取开始符号之后的所有字符
        /// </summary>
        /// <param name="content">原始内容</param>
        /// <param name="startStr">起始字符串</param>
        /// <param name="endStr">结束字符串</param>
        /// <returns>最后一个匹配项行中查找到的内容</returns>
        public static string FindByLineLast(this string content, string startStr, string endStr = "")
        {
            var results = content.FindByLine(startStr, endStr);
            return results.Count > 0 ? results[results.Count - 1] : string.Empty;
        }

        #endregion 逐行查找指定区间的最后一个匹配项
    }
}